/*
    * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved.
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    *
    * This code is free software; you can redistribute it and/or modify it
    * under the terms of the GNU General Public License version 2 only, as
    * published by the Free Software Foundation.  Oracle designates this
    * particular file as subject to the "Classpath" exception as provided
    * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  
  /*
   * The Original Code is HAT. The Initial Developer of the
   * Original Code is Bill Foote, with contributions from others
   * at JavaSoft/Sun.
   */
  
  package com.sun.tools.hat.internal.model;
  
  import java.lang.ref.SoftReference;
  import java.util.*;
  import com.sun.tools.hat.internal.parser.ReadBuffer;
  import com.sun.tools.hat.internal.util.Misc;
  
  /**
   *
   * @author      Bill Foote
   */
  
  /**
   * Represents a snapshot of the Java objects in the VM at one instant.
   * This is the top-level "model" object read out of a single .hprof or .bod
   * file.
   */
  
  public class Snapshot {
  
      public static long SMALL_ID_MASK = 0x0FFFFFFFFL;
      public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
  
      private static final JavaField[] EMPTY_FIELD_ARRAY = new JavaField[0];
      private static final JavaStatic[] EMPTY_STATIC_ARRAY = new JavaStatic[0];
  
      // all heap objects
      private Hashtable<Number, JavaHeapObject> heapObjects =
                   new Hashtable<Number, JavaHeapObject>();
  
      private Hashtable<Number, JavaClass> fakeClasses =
                   new Hashtable<Number, JavaClass>();
  
      // all Roots in this Snapshot
      private Vector<Root> roots = new Vector<Root>();
  
      // name-to-class map
      private Map<String, JavaClass> classes =
                   new TreeMap<String, JavaClass>();
  
      // new objects relative to a baseline - lazily initialized
      private volatile Map<JavaHeapObject, Boolean> newObjects;
  
      // allocation site traces for all objects - lazily initialized
      private volatile Map<JavaHeapObject, StackTrace> siteTraces;
  
      // object-to-Root map for all objects
      private Map<JavaHeapObject, Root> rootsMap =
                   new HashMap<JavaHeapObject, Root>();
  
      // soft cache of finalizeable objects - lazily initialized
      private SoftReference<Vector> finalizablesCache;
  
      // represents null reference
      private JavaThing nullThing;
  
      // java.lang.ref.Reference class
      private JavaClass weakReferenceClass;
      // index of 'referent' field in java.lang.ref.Reference class
      private int referentFieldIndex;
  
      // java.lang.Class class
      private JavaClass javaLangClass;
      // java.lang.String class
      private JavaClass javaLangString;
      // java.lang.ClassLoader class
      private JavaClass javaLangClassLoader;
 
     // unknown "other" array class
     private volatile JavaClass otherArrayType;
     // Stuff to exclude from reachable query
     private ReachableExcludes reachableExcludes;
     // the underlying heap dump buffer
     private ReadBuffer readBuf;
 
     // True iff some heap objects have isNew set
     private boolean hasNewSet;
     private boolean unresolvedObjectsOK;
 
     // whether object array instances have new style class or
     // old style (element) class.
     private boolean newStyleArrayClass;
 
     // object id size in the heap dump
     private int identifierSize = 4;
 
     // minimum object size - accounts for object header in
     // most Java virtual machines - we assume 2 identifierSize
     // (which is true for Sun's hotspot JVM).
     private int minimumObjectSize;
 
     public Snapshot(ReadBuffer buf) {
         nullThing = new HackJavaValue("<null>", 0);
         readBuf = buf;
     }
 
     public void setSiteTrace(JavaHeapObject obj, StackTrace trace) {
         if (trace != null && trace.getFrames().length != 0) {
             initSiteTraces();
             siteTraces.put(obj, trace);
         }
     }
 
     public StackTrace getSiteTrace(JavaHeapObject obj) {
         if (siteTraces != null) {
             return siteTraces.get(obj);
         } else {
             return null;
         }
     }
 
     public void setNewStyleArrayClass(boolean value) {
         newStyleArrayClass = value;
     }
 
     public boolean isNewStyleArrayClass() {
         return newStyleArrayClass;
     }
 
     public void setIdentifierSize(int size) {
         identifierSize = size;
         minimumObjectSize = 2 * size;
     }
 
     public int getIdentifierSize() {
         return identifierSize;
     }
 
     public int getMinimumObjectSize() {
         return minimumObjectSize;
     }
 
     public void addHeapObject(long id, JavaHeapObject ho) {
         heapObjects.put(makeId(id), ho);
     }
 
     public void addRoot(Root r) {
         r.setIndex(roots.size());
         roots.addElement(r);
     }
 
     public void addClass(long id, JavaClass c) {
         addHeapObject(id, c);
         putInClassesMap(c);
     }
 
     JavaClass addFakeInstanceClass(long classID, int instSize) {
         // Create a fake class name based on ID.
         String name = "unknown-class<@" + Misc.toHex(classID) + ">";
 
         // Create fake fields convering the given instance size.
         // Create as many as int type fields and for the left over
         // size create byte type fields.
         int numInts = instSize / 4;
         int numBytes = instSize % 4;
         JavaField[] fields = new JavaField[numInts + numBytes];
         int i;
         for (i = 0; i < numInts; i++) {
             fields[i] = new JavaField("unknown-field-" + i, "I");
         }
         for (i = 0; i < numBytes; i++) {
             fields[i + numInts] = new JavaField("unknown-field-" +
                                                 i + numInts, "B");
         }
 
         // Create fake instance class
         JavaClass c = new JavaClass(name, 0, 0, 0, 0, fields,
                                  EMPTY_STATIC_ARRAY, instSize);
         // Add the class
         addFakeClass(makeId(classID), c);
         return c;
     }
 
 
     /**
      * @return true iff it's possible that some JavaThing instances might
      *          isNew set
      *
      * @see JavaThing.isNew()
      */
     public boolean getHasNewSet() {
         return hasNewSet;
     }
 
     //
     // Used in the body of resolve()
     //
     private static class MyVisitor extends AbstractJavaHeapObjectVisitor {
         JavaHeapObject t;
         public void visit(JavaHeapObject other) {
             other.addReferenceFrom(t);
         }
     }
 
     // To show heap parsing progress, we print a '.' after this limit
     private static final int DOT_LIMIT = 5000;
 
     /**
      * Called after reading complete, to initialize the structure
      */
     public void resolve(boolean calculateRefs) {
         System.out.println("Resolving " + heapObjects.size() + " objects...");
 
         // First, resolve the classes.  All classes must be resolved before
         // we try any objects, because the objects use classes in their
         // resolution.
         javaLangClass = findClass("java.lang.Class");
         if (javaLangClass == null) {
             System.out.println("WARNING:  hprof file does not include java.lang.Class!");
             javaLangClass = new JavaClass("java.lang.Class", 0, 0, 0, 0,
                                  EMPTY_FIELD_ARRAY, EMPTY_STATIC_ARRAY, 0);
             addFakeClass(javaLangClass);
         }
         javaLangString = findClass("java.lang.String");
         if (javaLangString == null) {
             System.out.println("WARNING:  hprof file does not include java.lang.String!");
             javaLangString = new JavaClass("java.lang.String", 0, 0, 0, 0,
                                  EMPTY_FIELD_ARRAY, EMPTY_STATIC_ARRAY, 0);
             addFakeClass(javaLangString);
         }
         javaLangClassLoader = findClass("java.lang.ClassLoader");
         if (javaLangClassLoader == null) {
             System.out.println("WARNING:  hprof file does not include java.lang.ClassLoader!");
             javaLangClassLoader = new JavaClass("java.lang.ClassLoader", 0, 0, 0, 0,
                                  EMPTY_FIELD_ARRAY, EMPTY_STATIC_ARRAY, 0);
             addFakeClass(javaLangClassLoader);
         }
 
         for (JavaHeapObject t : heapObjects.values()) {
             if (t instanceof JavaClass) {
                 t.resolve(this);
             }
         }
 
         // Now, resolve everything else.
         for (JavaHeapObject t : heapObjects.values()) {
             if (!(t instanceof JavaClass)) {
                 t.resolve(this);
             }
         }
 
         heapObjects.putAll(fakeClasses);
         fakeClasses.clear();
 
         weakReferenceClass = findClass("java.lang.ref.Reference");
         if (weakReferenceClass == null)  {      // JDK 1.1.x
             weakReferenceClass = findClass("sun.misc.Ref");
             referentFieldIndex = 0;
         } else {
             JavaField[] fields = weakReferenceClass.getFieldsForInstance();
             for (int i = 0; i < fields.length; i++) {
                 if ("referent".equals(fields[i].getName())) {
                     referentFieldIndex = i;
                     break;
                 }
             }
         }
 
         if (calculateRefs) {
             calculateReferencesToObjects();
             System.out.print("Eliminating duplicate references");
             System.out.flush();
             // This println refers to the *next* step
         }
         int count = 0;
         for (JavaHeapObject t : heapObjects.values()) {
             t.setupReferers();
             ++count;
             if (calculateRefs && count % DOT_LIMIT == 0) {
                 System.out.print(".");
                 System.out.flush();
             }
         }
         if (calculateRefs) {
             System.out.println("");
         }
 
         // to ensure that Iterator.remove() on getClasses()
         // result will throw exception..
         classes = Collections.unmodifiableMap(classes);
     }
 
     private void calculateReferencesToObjects() {
         System.out.print("Chasing references, expect "
                          + (heapObjects.size() / DOT_LIMIT) + " dots");
         System.out.flush();
         int count = 0;
         MyVisitor visitor = new MyVisitor();
         for (JavaHeapObject t : heapObjects.values()) {
             visitor.t = t;
             // call addReferenceFrom(t) on all objects t references:
             t.visitReferencedObjects(visitor);
             ++count;
             if (count % DOT_LIMIT == 0) {
                 System.out.print(".");
                 System.out.flush();
             }
         }
         System.out.println();
         for (Root r : roots) {
             r.resolve(this);
             JavaHeapObject t = findThing(r.getId());
             if (t != null) {
                 t.addReferenceFromRoot(r);
             }
         }
     }
 
     public void markNewRelativeTo(Snapshot baseline) {
         hasNewSet = true;
         for (JavaHeapObject t : heapObjects.values()) {
             boolean isNew;
             long thingID = t.getId();
             if (thingID == 0L || thingID == -1L) {
                 isNew = false;
             } else {
                 JavaThing other = baseline.findThing(t.getId());
                 if (other == null) {
                     isNew = true;
                 } else {
                     isNew = !t.isSameTypeAs(other);
                 }
             }
             t.setNew(isNew);
         }
     }
 
     public Enumeration<JavaHeapObject> getThings() {
         return heapObjects.elements();
     }
 
 
     public JavaHeapObject findThing(long id) {
         Number idObj = makeId(id);
         JavaHeapObject jho = heapObjects.get(idObj);
         return jho != null? jho : fakeClasses.get(idObj);
     }
 
     public JavaHeapObject findThing(String id) {
         return findThing(Misc.parseHex(id));
     }
 
     public JavaClass findClass(String name) {
         if (name.startsWith("0x")) {
             return (JavaClass) findThing(name);
         } else {
             return classes.get(name);
         }
     }
 
     /**
      * Return an Iterator of all of the classes in this snapshot.
      **/
     public Iterator getClasses() {
         // note that because classes is a TreeMap
         // classes are already sorted by name
         return classes.values().iterator();
     }
 
     public JavaClass[] getClassesArray() {
         JavaClass[] res = new JavaClass[classes.size()];
         classes.values().toArray(res);
         return res;
     }
 
     public synchronized Enumeration getFinalizerObjects() {
         Vector obj;
         if (finalizablesCache != null &&
             (obj = finalizablesCache.get()) != null) {
             return obj.elements();
         }
 
         JavaClass clazz = findClass("java.lang.ref.Finalizer");
         JavaObject queue = (JavaObject) clazz.getStaticField("queue");
         JavaThing tmp = queue.getField("head");
         Vector<JavaHeapObject> finalizables = new Vector<JavaHeapObject>();
         if (tmp != getNullThing()) {
             JavaObject head = (JavaObject) tmp;
             while (true) {
                 JavaHeapObject referent = (JavaHeapObject) head.getField("referent");
                 JavaThing next = head.getField("next");
                 if (next == getNullThing() || next.equals(head)) {
                     break;
                 }
                 head = (JavaObject) next;
                 finalizables.add(referent);
             }
         }
         finalizablesCache = new SoftReference<Vector>(finalizables);
         return finalizables.elements();
     }
 
     public Enumeration<Root> getRoots() {
         return roots.elements();
     }
 
     public Root[] getRootsArray() {
         Root[] res = new Root[roots.size()];
         roots.toArray(res);
         return res;
     }
 
     public Root getRootAt(int i) {
         return roots.elementAt(i);
     }
 
     public ReferenceChain[]
     rootsetReferencesTo(JavaHeapObject target, boolean includeWeak) {
         Vector<ReferenceChain> fifo = new Vector<ReferenceChain>();  // This is slow... A real fifo would help
             // Must be a fifo to go breadth-first
         Hashtable<JavaHeapObject, JavaHeapObject> visited = new Hashtable<JavaHeapObject, JavaHeapObject>();
         // Objects are added here right after being added to fifo.
         Vector<ReferenceChain> result = new Vector<ReferenceChain>();
         visited.put(target, target);
         fifo.addElement(new ReferenceChain(target, null));
 
         while (fifo.size() > 0) {
             ReferenceChain chain = fifo.elementAt(0);
             fifo.removeElementAt(0);
             JavaHeapObject curr = chain.getObj();
             if (curr.getRoot() != null) {
                 result.addElement(chain);
                 // Even though curr is in the rootset, we want to explore its
                 // referers, because they might be more interesting.
             }
             Enumeration referers = curr.getReferers();
             while (referers.hasMoreElements()) {
                 JavaHeapObject t = (JavaHeapObject) referers.nextElement();
                 if (t != null && !visited.containsKey(t)) {
                     if (includeWeak || !t.refersOnlyWeaklyTo(this, curr)) {
                         visited.put(t, t);
                         fifo.addElement(new ReferenceChain(t, chain));
                     }
                 }
             }
         }
 
         ReferenceChain[] realResult = new ReferenceChain[result.size()];
         for (int i = 0; i < result.size(); i++) {
             realResult[i] =  result.elementAt(i);
         }
         return realResult;
     }
 
     public boolean getUnresolvedObjectsOK() {
         return unresolvedObjectsOK;
     }
 
     public void setUnresolvedObjectsOK(boolean v) {
         unresolvedObjectsOK = v;
     }
 
     public JavaClass getWeakReferenceClass() {
         return weakReferenceClass;
     }
 
     public int getReferentFieldIndex() {
         return referentFieldIndex;
     }
 
     public JavaThing getNullThing() {
         return nullThing;
     }
 
     public void setReachableExcludes(ReachableExcludes e) {
         reachableExcludes = e;
     }
 
     public ReachableExcludes getReachableExcludes() {
         return reachableExcludes;
     }
 
     // package privates
     void addReferenceFromRoot(Root r, JavaHeapObject obj) {
         Root root = rootsMap.get(obj);
         if (root == null) {
             rootsMap.put(obj, r);
         } else {
             rootsMap.put(obj, root.mostInteresting(r));
         }
     }
 
     Root getRoot(JavaHeapObject obj) {
         return rootsMap.get(obj);
     }
 
     JavaClass getJavaLangClass() {
         return javaLangClass;
     }
 
     JavaClass getJavaLangString() {
         return javaLangString;
     }
 
     JavaClass getJavaLangClassLoader() {
         return javaLangClassLoader;
     }
 
     JavaClass getOtherArrayType() {
         if (otherArrayType == null) {
             synchronized(this) {
                 if (otherArrayType == null) {
                     addFakeClass(new JavaClass("[<other>", 0, 0, 0, 0,
                                      EMPTY_FIELD_ARRAY, EMPTY_STATIC_ARRAY,
                                      0));
                     otherArrayType = findClass("[<other>");
                 }
             }
         }
         return otherArrayType;
     }
 
     JavaClass getArrayClass(String elementSignature) {
         JavaClass clazz;
         synchronized(classes) {
             clazz = findClass("[" + elementSignature);
             if (clazz == null) {
                 clazz = new JavaClass("[" + elementSignature, 0, 0, 0, 0,
                                    EMPTY_FIELD_ARRAY, EMPTY_STATIC_ARRAY, 0);
                 addFakeClass(clazz);
                 // This is needed because the JDK only creates Class structures
                 // for array element types, not the arrays themselves.  For
                 // analysis, though, we need to pretend that there's a
                 // JavaClass for the array type, too.
             }
         }
         return clazz;
     }
 
     ReadBuffer getReadBuffer() {
         return readBuf;
     }
 
     void setNew(JavaHeapObject obj, boolean isNew) {
         initNewObjects();
         if (isNew) {
             newObjects.put(obj, Boolean.TRUE);
         }
     }
 
     boolean isNew(JavaHeapObject obj) {
         if (newObjects != null) {
             return newObjects.get(obj) != null;
         } else {
             return false;
         }
     }
 
     // Internals only below this point
     private Number makeId(long id) {
         if (identifierSize == 4) {
             return new Integer((int)id);
         } else {
             return new Long(id);
         }
     }
 
     private void putInClassesMap(JavaClass c) {
         String name = c.getName();
         if (classes.containsKey(name)) {
             // more than one class can have the same name
             // if so, create a unique name by appending
             // - and id string to it.
             name += "-" + c.getIdString();
         }
         classes.put(c.getName(), c);
     }
 
     private void addFakeClass(JavaClass c) {
         putInClassesMap(c);
         c.resolve(this);
     }
 
     private void addFakeClass(Number id, JavaClass c) {
         fakeClasses.put(id, c);
         addFakeClass(c);
     }
 
     private synchronized void initNewObjects() {
         if (newObjects == null) {
             synchronized (this) {
                 if (newObjects == null) {
                     newObjects = new HashMap<JavaHeapObject, Boolean>();
                 }
             }
         }
     }
 
     private synchronized void initSiteTraces() {
         if (siteTraces == null) {
             synchronized (this) {
                 if (siteTraces == null) {
                     siteTraces = new HashMap<JavaHeapObject, StackTrace>();
                 }
             }
         }
     }
 }